<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<style>
  ul{
    list-style: none;
    display: flex;
  }
  li{
    width: 200px;
    text-align: center;
  }
</style>
<body>
    <ul>
        <li>童装</li>
        <li>男装</li>
        <li>女装</li>
        <li>电子产品</li>
    </ul>
    <div class="box">欢迎来到童装专区</div>
</body>
</html>
<script>
   // 什么是闭包？
   // 一个作用域有权访问另外一个作用域的变量我们称为闭包； (通俗的说就是函数嵌套函数。)
//    function fn () {
//      let a = 10;
//      function ftn(){
//        console.log(a);
//      }
//    }
   

//    let arr = ['欢迎来到童装专区','欢迎来到男装专区','欢迎来到女装专区','欢迎来到电子产品专区']

   
//    let lis = document.querySelectorAll('li');
//    console.log(lis);
//   for(var i=0; i<lis.length; i++){
//     // console.log(i);
//     (function(i){
//       // i == 0
//       lis[i].onclick = function(){
//         document.querySelector('.box').innerHTML = arr[i];
//       }
//     })(i)
//     // (function(i){
//     //   // i == 1
//     //   lis[i].onclick = function(){
//     //     document.querySelector('.box').innerHTML = arr[i];
//     //   }
//     // })(i)
//   }


//   (function(val){ // 我们称为自执行函数。
//     console.log(val);
//   })(123)

// 闭包的优点：闭包中的变量不会被垃圾回收机制回收，会永远驻扎在内存中，也会形成作用域隔离。
// 闭包的缺点：变量长期驻扎在内存中，过多使用会导致，内存泄漏。


// 什么是递归函数？
// 在函数内部自己调用自己，我们称为递归函数。

// function fn(){ // 这是一个递归函数
//   fn();
// }
// fn();
// 递归函数一定要慎用。

// for(var i = 0; i<10;i++){
//     console.log(i);
// }

// var i = 0;
// function fn (){ // 这个就是一个递归函数。
//   if (i<10){
//     console.log(i);
//     i++;
//     fn();
//   }
// }
// fn();


// let arr = [
//     {name:"小明",id:1,children:[{name:"大明",id:6,children:[{name:"刘能",id:9}]}]},
//     {name:"小李",id:2,children:null},
//     {name:"小红",id:3,children:[{name:"赵四",id:8}]},
//     {name:"小白",id:4,children:null}
// ]


// [1,2,3,4,6,8,9]
// let arr1 = [];
// function fn (Arr){
//     Arr.forEach(item => {
//     //   debugger
//       arr1.push(item.id);
//       if (item.children instanceof Array){
//         fn(item.children);
//       }
//     });
// }
// fn(arr);
// console.log(arr1);



// 高阶函数？数组的高阶函数有哪些？
// 第一个闭包就是高阶函数的一种，回调函数也是高阶函数的一种。
// 在一个函数的内部，调用其他函数，或者把函数当成返回值，返回出去，我们称这样的函数为高阶函数。


// function fn (){ // 也是高阶函数。
//   return function ftn(){
//     console.log('我被打印了！');
//   }
// }
// console.log(fn ());
// fn()();

// 变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
// let a = fn ();
// console.log(a);
// a();
// fn()();


// 数组的高阶函数？(some,every,find,findIndex)
// push
// arr.some(item => {})


// 函数的传参，（默认参数）

// function fn (val=1,val1=4){ // val=1,val1=4 这样的写法我们称为函数的默认参数。
//   return val+val1;
// }
// console.log(fn(2,5));

</script>